package cn.fbs.util;

import java.text.DateFormat;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Calendar;
import java.util.Date;
import java.util.GregorianCalendar;
import java.util.List;

/**
 * @program: springbootdemo
 * @description: 时间工具类
 * @author: wxk
 * @create: 2020-12-21 21:00
 **/
public class DateUtil {

    /**
     * yyyy-MM-dd HH:mm:ss
     */
    public static String    deaultDateTimeFormat = "yyyy-MM-dd HH:mm:ss";

    /**
     * yyyy-MM-dd
     */
    public static String    deaultDateFormat     = "yyyy-MM-dd";
    /**
     * yyyyMMdd
     */
    public static String    deaultDateFormat1    = "yyyyMMdd";

    public static String    deaultTimeFormat     = "HH:mm:ss";

    private int             year;
    private int             month;
    public static final int YYYY                 = 1;
    public static final int YYYYMM               = 2;
    public static final int YYYYMMDD             = 3;
    public static final int YYYYMMDDhh           = 4;
    public static final int YYYYMMDDhhmm         = 5;
    public static final int YYYYMMDDhhmmss       = 6;
    public static final int YYYYMMDDhhmmssxxx    = 7;
    public static final int YY                   = 11;
    public static final int YYMM                 = 12;
    public static final int YYMMDD               = 13;
    public static final int YYMMDDhh             = 14;
    public static final int YYMMDDhhmm           = 15;
    public static final int YYMMDDhhmmss         = 16;
    public static final int YYMMDDhhmmssxxx      = 17;
    public static final int hh                   = 24;
    public static final int hhmm                 = 25;
    public static final int hhmmss               = 26;
    public static final int hhmmssxxx            = 27;
    GregorianCalendar       gc                   = new GregorianCalendar();

    /**
     * 获取当前时间
     * 
     * @return Date 当前时间
     * @author wxk
     */
    public static Date getCurrentTime() {
        Date currentTime = new Date(new Date().getTime());

        return currentTime;
    }

    /**
     * 取得本地系统的时间，时间格式由参数决定
     * 
     * @param format int 时间格式由常量决定
     * @return String 具有format格式的字符串
     * @author wxk
     */
    public static synchronized String getTime(int format) {
        Calendar time = Calendar.getInstance();
        return getTime(format, time);
    }

    /**
     * 该方法获取运行系统的当前时间并将其转换为yyyy-MM-dd HH:mm:ss格式
     * 
     * @return String 当前时间的yyyy-MM-dd HH:mm:ss格式化字符串
     * @author wxk
     */
    public static String getTimeStamp() {
        GregorianCalendar calendar = new GregorianCalendar();
        SimpleDateFormat dateFormat = new SimpleDateFormat(deaultDateTimeFormat);
        return dateFormat.format(calendar.getTime());
    }

    /**
     * 功能：将Date类型数据转换为YYYY-mm-dd字符,如果传入的参数日期是1900-01-01，那么返回的字符串为""
     * 
     * @param date Date 要转换的日期
     * @return String 转换后的字符
     * @author wxk
     */
    public static String dateToStr(Date date) {
        String retDate = dateToOriStr(date);
        if (retDate.equals("1900-01-01")) {
            retDate = "";
        }
        return retDate;
    }

    /**
     * 
     * <li>功能描述：将Date类型数据转换为yyyy-MM-dd HH:mm:ss字符。
     * 
     * @param date Date 要转换的日期
     * @return String 转换后的字符
     * @author wxk
     */
    public static String dateToOriStr(Date date) {
        if (date == null) {
            return "1900-01-01";
        }
        SimpleDateFormat dateFormat = new SimpleDateFormat(
            deaultDateTimeFormat);
        return dateFormat.format(date);
    }

    /**
     * 功能：将Date类型数据转换为yyyy-MM-dd字符
     * 
     * @param date Date 要转换的日期
     * @param formatStr String 转换的格式
     * @return String 转换后的字符
     * @author wxk
     */
    public static String dateToStr(Date date, String formatStr) {
        if (date == null) {
            return "";
        }
        SimpleDateFormat dateFormat = new SimpleDateFormat(formatStr);

        return dateFormat.format(date);
    }

    /**
     * 功能：将指定格式的字符串转换为Date类型数据
     * 
     * @param str String 要转换的日期
     * @return Date 转换后的Date类型数据
     * @author wxk
     */
    public static Date strToDate(String str) {
        SimpleDateFormat dateFormat = new SimpleDateFormat(deaultDateFormat);

        try {
            return dateFormat.parse(str);
        }
        catch (ParseException ex) {
            GregorianCalendar calendar = new GregorianCalendar();
            calendar.set(1900, 0, 1);
            return calendar.getTime();
        }
    }

    /**
     * 根据传入日期得到去年的
     * 
     * @param date String 传入的日期
     * 
     * @return String 去年的日期
     * @author wxk
     */
    public static synchronized String getLastYear(String date) {
        GregorianCalendar gregoriancalendar = (GregorianCalendar) Calendar.getInstance();
        gregoriancalendar.setTime(DateUtil.strToDate(date));
        gregoriancalendar.add(Calendar.YEAR, -1);
        return DateUtil.dateToOriStr(gregoriancalendar.getTime());
    }

    /**
     * 得到环比日期
     * 
     * @param date1 String 起始日期
     * @param date2 String 结束日期
     * @return int  环比日期
     * @author wxk
     */
    public static synchronized int toCompare(String date1, String date2) {
        GregorianCalendar gregoriancalendar = (GregorianCalendar) Calendar.getInstance();
        gregoriancalendar.setTime(DateUtil.strToDate(date1));
        GregorianCalendar gregoriancalendar1 = (GregorianCalendar) Calendar.getInstance();
        gregoriancalendar1.setTime(DateUtil.strToDate(date2));
        int day = 0;
        int year = gregoriancalendar1.get(Calendar.YEAR) - gregoriancalendar.get(Calendar.YEAR);
        if (year == 0) {
            day = gregoriancalendar1.get(Calendar.DAY_OF_YEAR)
                - gregoriancalendar.get(Calendar.DAY_OF_YEAR);
        }
        if (year > 0) {
            int i = 0;
            if (gregoriancalendar.isLeapYear(gregoriancalendar.get(Calendar.YEAR))) {
                day = 366 - gregoriancalendar.get(Calendar.DAY_OF_YEAR);
            }
            else {
                day = 365 - gregoriancalendar.get(Calendar.DAY_OF_YEAR);
            }
            for (i = 1; i < year; i++) {
                int sd = gregoriancalendar.get(Calendar.YEAR) + i;
                if (gregoriancalendar.isLeapYear(sd)) {
                    day += 366;
                }
                else {
                    day += 365;
                }
            }
            if (i == year) {
                day += gregoriancalendar1.get(Calendar.DAY_OF_YEAR);
            }
        }
        return day + 1;
    }

    /**
     * 得到传入日期的前几天
     * 
     * @param date String 传入日期
     * @param j int 前几天
     * @return String 传入日期的前几天
     * @author wxk
     */
    public static synchronized String getHBDate(String date, int j) {
        GregorianCalendar gregoriancalendar = (GregorianCalendar) Calendar.getInstance();
        gregoriancalendar.setTime(DateUtil.strToDate(date));
        gregoriancalendar.add(Calendar.DATE, -j);
        return DateUtil.dateToOriStr(gregoriancalendar.getTime());

    }

    /**
     * 得到传入日期月份的第一天
     * 
     * @param date Date 传入日期
     * 
     * @return Date 传入日期月份的第一天
     * @author wxk
     */
    public static synchronized Date getFirstDayOfMonth(Date date) {
        GregorianCalendar gregoriancalendar = (GregorianCalendar) Calendar.getInstance();
        gregoriancalendar.setTime(date);
        gregoriancalendar.set(5, 1);
        return gregoriancalendar.getTime();
    }

    /**
     * 得到传入月份一共多少天
     * 
     * @param theMonth int 月份
     * @return int 传入月份一共的天数
     * @author wxk
     */
    public int daysInMonth(int theMonth) {
        int[] daysInMonths = { 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 };
        daysInMonths[1] += gc.isLeapYear(year) ? 1 : 0;
        return daysInMonths[theMonth - 1];
    }

    /**
     * 传入yyyy-mm-dd字符串，得到该月的最大那天的日期字符串
     * 
     * @param thisDate String 传入的yyyy-mm-dd字符串
     * @return String String 最大那天的日期字符串
     * @author wxk
     */
    public String lastDayInMonth(String thisDate) {
        month = Integer.parseInt(thisDate.substring(5, 7));
        year = Integer.parseInt(thisDate.substring(0, 4));
        gc = new GregorianCalendar(year, month, 1);
        int lastday = daysInMonth(month);
        return thisDate.substring(0, 8) + lastday;
    }

    /**
     * 得到传入的日期上上个月的第一天日期字符串
     * 
     * @param thisDate String 传入的日期
     * @return mydate String 上上个月的第一天日期字符串
     * @author wxk
     */
    public static String getMonthbeforeLast(String thisDate) {
        int monthtemp = Integer.parseInt(thisDate.substring(5, 7));
        int yeartemp = Integer.parseInt(thisDate.substring(0, 4));
        Calendar calendar = Calendar.getInstance();
        calendar.set(yeartemp, monthtemp - 3, 1);
        String mydate = dateToOriStr(calendar.getTime());
        return mydate;
    }

    /**
     * 得到传入的日期上个月的第一天日期字符串
     * 
     * @param thisDate String 传入的日期
     * @return mydate String 上个月的第一天日期字符串
     * @author wxk
     */
    public static String getMonthbefore(String thisDate) {
        int monthtemp = Integer.parseInt(thisDate.substring(5, 7));
        int yeartemp = Integer.parseInt(thisDate.substring(0, 4));
        Calendar calendar = Calendar.getInstance();
        calendar.set(yeartemp, monthtemp - 2, 1);
        String mydate = dateToOriStr(calendar.getTime());
        return mydate;
    }

    /**
     * 得到传入日期前一天的的日期
     * 
     * @param date Date 传入日期
     * @return Date 前一天的的日期
     * @author wxk
     */
    public static synchronized Date getYesterday(Date date) {
        GregorianCalendar gregoriancalendar = (GregorianCalendar) Calendar.getInstance();
        gregoriancalendar.setTime(date);
        gregoriancalendar.add(Calendar.DATE, -1);
        return gregoriancalendar.getTime();
    }

    /**
     * 得到传入日期前两天的的日期
     * 
     * @param date Date 传入日期
     * 
     * @return Date 前两天的的日期
     * @author wxk
     */
    public static synchronized Date getDayBeforeYesterday(Date date) {
        GregorianCalendar gregoriancalendar = (GregorianCalendar) Calendar.getInstance();
        gregoriancalendar.setTime(date);
        gregoriancalendar.add(Calendar.DATE, -2);
        return gregoriancalendar.getTime();
    }

    /**
     * 功能：将指定格式的字符串转换为Date类型 如果字符串日期不合法，缺省为"1900-01-01"
     * 
     * @param str String 需要转换的日期字
     * @param formatStr String 转换的日期格式
     * @return Date 转换后的日期类型
     * @author wxk
     */
    public static Date strToDate(String str, String formatStr) {
        SimpleDateFormat dateFormat = new SimpleDateFormat(formatStr);

        try {
            return dateFormat.parse(str);
        }
        catch (ParseException ex) {
            GregorianCalendar calendar = new GregorianCalendar();
            calendar.set(1900, 1, 1);
            return calendar.getTime();
        }
    }

    /**
     * 
     * <li>功能描述：将Date类型数据转换为yyyy-MM-dd HH:mm:ss字符。
     * 
     * @param time Date 传入的日期
     * @return String 转换后的日期字符串
     * @author wxk
     */
    public static String timeToStr(Date time) {
        SimpleDateFormat dateFormat = new SimpleDateFormat(deaultDateTimeFormat);
        return dateFormat.format(time);
    }

    /**
     * 
     * <li>功能描述：返回当前日期字符串，格式为yyyy-MM-dd HH:mm:ss。
     * 
     * @return String 前日期字符串
     * @author wxk
     */
    public static String timeToStr() {
        return DateUtil.timeToStr(new Date());
    }

    /**
     * 
     * <li>功能描述：获取给定日期是星期几。
     * 
     * @param dat Date 给定日期
     * @return String 星期几
     * @author wxk
     */
    public static String getWeek(Date dat) {
        Calendar cal = Calendar.getInstance();
        cal.setTime(dat);
        int w = cal.get(Calendar.DAY_OF_WEEK) - 1;
        if (w == 0) {
            w = 7;
        }
        switch (w) {
            case 1:
                return "星期一";
            case 2:
                return "星期二";
            case 3:
                return "星期三";
            case 4:
                return "星期四";
            case 5:
                return "星期五";
            case 6:
                return "星期六";
            case 7:
                return "星期日";
        }
        return "";
    }

    /**
     * 
     * <li>功能描述：获取两个日期差，格式为 X天X小时X分X秒。
     * 
     * @param fromTime Date 起始日期
     * @param toTime Date 结束日期
     * @return String 日期差
     * @author wxk
     */
    public static String getTimeDifference(Date fromTime, Date toTime) {
        String difference = "";
        try {
            long l = fromTime.getTime() - toTime.getTime();
            if (l < 0) {
                return "----";
            }
            long day = l / (24 * 60 * 60 * 1000);
            long hour = l / (60 * 60 * 1000) - day * 24;
            long min = (l / (60 * 1000)) - day * 24 * 60 - hour * 60;
            long s = l / 1000 - day * 24 * 60 * 60 - hour * 60 * 60 - min * 60;
            difference = "" + day + "天" + hour + "小时" + min + "分" + s + "秒";
        }
        catch (Exception e) {
            e.printStackTrace();
        }
        return difference;
    }

    public static long getTimeDifferenceMinute(Date fromTime, Date toTime) {
        long min = 0;
        try {
            long l = toTime.getTime() - fromTime.getTime();
            if (l < 0) {
                return min;
            }
            min = l / (60 * 1000);
        }
        catch (Exception e) {
            e.printStackTrace();
        }
        return min;
    }

    /**
     * 
     * <li>功能描述：获取两个日期差，格式为 X天X小时X分X秒。
     * 
     * @param fromTime1 String 起始日期
     * @param toTime String 结束日期
     * @return String 日期差
     * @author wxk
     */
    public static String getTimeDifference(String fromTime1, Date toTime) {
        String difference = "";
        try {

            // SimpleDateFormat df = new
            // SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
            Date fromTime = strToDate(fromTime1);
            long l = fromTime.getTime() - toTime.getTime();
            if (l < 0) {
                return "----";
            }
            long day = l / (24 * 60 * 60 * 1000);
            long hour = l / (60 * 60 * 1000) - day * 24;
            long min = (l / (60 * 1000)) - day * 24 * 60 - hour * 60;
            long s = l / 1000 - day * 24 * 60 * 60 - hour * 60 * 60 - min * 60;
            difference = "" + day + "天" + hour + "小时" + min + "分" + s + "秒";
        }
        catch (Exception e) {
            e.printStackTrace();
        }
        return difference;
    }

    /**
     * <li>功能描述：得到格式化的时间
     * 
     * @param format int 时间格式 
     * @param time Calendar 时间 
     * @return String 格式化字符串
     * @author wxk
     */
    private static synchronized String getTime(int format, Calendar time) {
        StringBuffer cTime = new StringBuffer(10);
        int miltime = time.get(Calendar.MILLISECOND);
        int second = time.get(Calendar.SECOND);
        int minute = time.get(Calendar.MINUTE);
        int hour = time.get(Calendar.HOUR_OF_DAY);
        int day = time.get(Calendar.DAY_OF_MONTH);
        int month = time.get(Calendar.MONTH) + 1;
        int year = time.get(Calendar.YEAR);
        if (format > 10) {
            year = year - 2000;

        }
        if (format < 20) {
            if (format < 10) {
                cTime.append(year);
            }
            else if (format < 20) {
                cTime.append(getFormatTime(year, 2));
            }
        }
        if ((format < 20 && format > 11) || (format > 1 && format < 10)) {
            cTime.append(getFormatTime(month, 2));
        }
        if ((format < 20 && format > 12) || (format > 2 && format < 10)) {
            cTime.append(getFormatTime(day, 2));
        }
        if ((format > 13 && format < 20) || (format > 3 && format < 10)
            || (format > 23 && format < 30)) {
            cTime.append(getFormatTime(hour, 2));
        }
        if ((format > 14 && format < 20) || (format > 4 && format < 10)
            || (format > 24 && format < 30)) {
            cTime.append(getFormatTime(minute, 2));
        }
        if ((format > 15 && format < 20) || (format > 5 && format < 10)
            || (format > 25 && format < 30)) {
            cTime.append(getFormatTime(second, 2));
        }
        if ((format > 16 && format < 20) || (format > 6 && format < 10)
            || (format > 26 && format < 30)) {
            cTime.append(getFormatTime(miltime, 3));
        }
        return cTime.toString();
    }

    /**
     * <li>功能描述：格式化日期（不够给定长度的补零）
     * 
     * @param time int 要转换格式的时间
     * @param format int 转换的格式
     * @return String 转换的时间
     * @author wxk
     */
    private static synchronized String getFormatTime(int time, int format) {
        StringBuffer numm = new StringBuffer();
        int length = String.valueOf(time).length();

        if (format < length) {
            return null;
        }

        for (int i = 0; i < format - length; i++) {
            numm.append("0");
        }
        numm.append(time);
        return numm.toString().trim();
    }

    /**
     * <li>功能描述：得到延时后的时间
     * 
     * @param format int 时间格式
     * @param m int 延时分钟
     * @return String 结果时间字符串
     * @author wxk
     */
    public static synchronized String getAfterTime(int format, int m) {
        Calendar time = Calendar.getInstance();
        time.add(Calendar.MINUTE, m);
        return getTime(format, time);
    }

    /**
     * <li>功能描述：得到倒退后的时间
     * 
     * @param format int 时间格式
     * @param m int 倒退分钟
     * @return String 结果时间字符串
     * @author wxk
     */
    public static synchronized String getBeforTime(int format, int m) {
        Calendar time = Calendar.getInstance();
        time.add(Calendar.MINUTE, -m);
        return getTime(format, time);

    }

    /**
     * <li>功能描述：将数据库中存储的日期数字字符串转化为日期格式字符串。
     * 
     * @param arg String 日期全数字字符串
     * @return String 格式化后的日期
     * @author wxk
     */

    public static String getDateString(String arg) {
        StringBuffer sb = new StringBuffer(arg.substring(0, 4));
        sb.append("-" + arg.substring(4, 6));
        sb.append("-" + arg.substring(6, 8));
        return sb.toString();
    }

    /**
     * <li>功能描述：将数据库中存储的时分秒数字字符串转化为时间格式字符串。
     * 
     * @param arg1 String 时分秒全数字字符串
     * @return String 转化为时间格式的字符串
     * @author wxk
     */

    public static String getHourString(String arg1) {
        String arg = arg1;
        if (arg.length() < 6) {
            arg = "0" + arg;
        }
        StringBuffer sb = new StringBuffer(arg.substring(0, 2));
        sb.append(":" + arg.substring(2, 4));
        sb.append(":" + arg.subSequence(4, 6));
        return sb.toString();
    }

    /**
     * <li>功能描述：将数据库中存储的日期时间数字字符串转化为日期格式字符串。
     * 
     * @param arg String 日期及时间全数字字符串
     * @return String 转化为日期格式的字符串
     * @author wxk
     */
    public static String getTimeString(String arg) {
        if (arg == null || arg.trim().length() < 12) {
            return "未登录";
        }
        StringBuffer sb = new StringBuffer(arg.substring(0, 4));
        sb.append("-" + arg.substring(4, 6));
        sb.append("-" + arg.substring(6, 8));
        sb.append(" " + arg.substring(8, 10));
        sb.append(":" + arg.substring(10, 12));
        return sb.toString();
    }

    /**
     * <li>功能描述：将java日期类型转换为全数字的字符串,截取到日期
     * 
     * @param d Date java日期类型
     * @return String 全数字的字符串
     * @author wxk
     */
    public static String getDateString(Date d) {
        DateFormat albumDate = new SimpleDateFormat(deaultDateFormat);
        return albumDate.format(d);
    }

    /**
     * <li>功能描述：将java日期类型转换为全数字的字符串,截取到日期
     * 
     * @param d Date java日期类型
     * @return String 全数字的字符串
     * @author wxk
     */
    public static String getDateString1(Date d) {
        DateFormat albumDate = new SimpleDateFormat(deaultDateFormat1);
        return albumDate.format(d);
    }

    /**
     * <li>功能描述：得到当前日期，格式为yyyy-MM-dd
     * 
     * @return String 当前日期
     * @author wxk
     */
    public static String getDateString() {
        DateFormat albumDate = new SimpleDateFormat(deaultDateFormat);
        return albumDate.format(new Date());
    }

    /**
     * <li>功能描述：根据指定的格式得到当前日期
     * 
     * @param format String 指定的格式  
     * @return String 当前日期
     * @author wxk
     */
    public static String getDateFormatString(String format) {
        DateFormat albumDate = new SimpleDateFormat(format);
        return albumDate.format(new Date());
    }

    /**
     * <li>功能描述：将java日期类型转换为全数字的字符串,截取到秒
     * 
     * @param d Date java日期类型
     * @return String 转换为全数字的字符串
     * @author wxk
     */
    public static String getDateTimeString(Date d) {
        DateFormat albumTime = new SimpleDateFormat(deaultDateTimeFormat);
        return albumTime.format(d);
    }

    /**
     * <li>功能描述：获得字符串date的日期类型对象。
     * 
     * @param date String 字符串date
     * @return Date 日期类型对象
     * @author wxk
     */
    public static Date getDate(String date) {
        DateFormat albumDate = new SimpleDateFormat("yyyyMMdd");
        try {
            return albumDate.parse(date);
        }
        catch (ParseException e) {
            e.printStackTrace();
        }
        return null;
    }

    /**
     * <li>功能描述：获得字符串日期和时间类型日期。
     * 
     * @param date String 字符串日期和时间
     * @return Date 日期
     * @author wxk
     */

    public static Date getDateAndTime(String date) {
        DateFormat albumTime = new SimpleDateFormat("yyyyMMddHHmmss");
        try {
            return albumTime.parse(date);
        }
        catch (ParseException e) {
            e.printStackTrace();
        }
        return null;
    }

    /**
     * <li>功能描述：格式化输出日期
     * 
     * @param date Date 日期
     * @param format String 格式
     * @return String 返回字符型日期
     * @author wxk
     */
    public static String format(Date date, String format) {
        String result = "";
        try {
            if (date != null) {
                DateFormat df = new SimpleDateFormat(format);
                result = df.format(date);
            }
        }
        catch (Exception e) {
        }
        return result;
    }

    /**
     * <li>功能描述：返回星期
     * 
     * @param date Date 日期
     * @return int 返回星期
     * @author wxk
     */
    public static int getWeekInt(Date date) {
        Calendar c = Calendar.getInstance();
        c.setTime(date);
        return c.get(Calendar.DAY_OF_WEEK);
    }

    /**
     * 
     * <li>功能描述：验证格式。
     * @param str 日期串
     * @param strformat 格式
     * @return
     * boolean 
     * @author wxk
     */
    public static boolean isValidDate(String str, String strformat) {
        boolean convertSuccess = true;
        SimpleDateFormat format = new SimpleDateFormat(strformat);
        try {
            format.setLenient(false);
            format.parse(str);
        }
        catch (ParseException e) {
            convertSuccess = false;
        }
        return convertSuccess;
    }

    /**
     * 
     * <li>功能描述：计算两个日期之间年月间隔。
     * @param minDate 开始日期
     * @param maxDate 结束日期
     * @param format 日期格式
     * @return
     * @throws ParseException
     * List<String> 
     * @author wxk
     */
    public static List<String> getMonthBetween(String minDate, String maxDate, String format)
        throws ParseException {
        ArrayList<String> result = new ArrayList<String>();
        SimpleDateFormat sdf = new SimpleDateFormat(format);// 格式化为年月

        Calendar min = Calendar.getInstance();
        Calendar max = Calendar.getInstance();

        min.setTime(sdf.parse(minDate));
        min.set(min.get(Calendar.YEAR), min.get(Calendar.MONTH), 1);

        max.setTime(sdf.parse(maxDate));
        max.set(max.get(Calendar.YEAR), max.get(Calendar.MONTH), 2);

        Calendar curr = min;
        while (curr.before(max)) {
            result.add(sdf.format(curr.getTime()));
            curr.add(Calendar.MONTH, 1);
        }
        return result;
    }

    /**
     * 
     * <li>功能描述：得到两个日期之间得所有日子。
     * @param startTime
     * @param endTime
     * @return
     * List<String> 
     * @author wxk
     */
    public static List<String> getDays(String startTime, String endTime) {

        // 返回的日期集合
        List<String> days = new ArrayList<String>();

        DateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd");
        try {
            Date start = dateFormat.parse(startTime);
            Date end = dateFormat.parse(endTime);

            Calendar tempStart = Calendar.getInstance();
            tempStart.setTime(start);

            Calendar tempEnd = Calendar.getInstance();
            tempEnd.setTime(end);
            tempEnd.add(Calendar.DATE, +1);// 日期加1(包含结束)
            while (tempStart.before(tempEnd)) {
                days.add(dateFormat.format(tempStart.getTime()));
                tempStart.add(Calendar.DAY_OF_YEAR, 1);
            }

        }
        catch (ParseException e) {
            e.printStackTrace();
        }

        return days;
    }
}
